let leftHeight = 0,
  rightHeight = 0,
  query;
//  表单验证  函数
import {
  verificationEvent
} from './utils/validation'
/**
 * 配置文件
 */
let App = getApp();
let that;
//  页面 方法
let event = {
  //  列表展示 的数据
  // 页面初次加载完成  生命钩子 ----
  onLoad(options) {
    /**
     * interFace  optionsObj{
     *    ([propname:String]) : string
     * }
     * @param options {}  包含路由参数
     */
    that = this;
    let page_inset = new Page_inset(that);
    //  页面初始化 数据
    /**
     * 页面data 中设置的 参数 会覆盖 全局设置的参数
     */
    let newData = Object.assign(page_inset.init(), that.data);
    that.setData({
      ...newData,
    });
    //   数据初始化完   请求 数据
    that.init(options, page_inset, function () { });
    //  自定义方法实例对象
    that.setData({
      Page_inset: page_inset,
    });
  },
  //  scroll view   EventHandel
  //  上拉刷新
  onUpLoad: function () {
    this.data.Page_inset.upLoad();
  },
  //  下拉触底
  onDownLoad: function (e) {
    this.data.Page_inset.downLoad();
  },
  //  分页
  getList(callback) {
    let that = this;
    let pages = getCurrentPages();
    let oldData = that.data.list.data;
    callback(pages[pages.length - 1].route, function (res) {
      that.setData({
        "list.data": oldData.concat(res.data?.data?.List?.data || []),
      });
    });
  },

  //  跳转详情页
  goProduct: function (e) {
    let {
      currentTarget: {
        dataset: {
          value
        },
      },
    } = e;
    wx.navigateTo({
      url: `/pages/product/index/index?type=1&id= ${JSON.stringify(value)}`,
    });
  },
  //  弹层显示隐藏
  popovHandel: function (e, instance) {
    /**
     * 弹窗
     *@param {  e.currentTarget  } 事件源
     *@param { instance } 触发的组件实例对象
     *@param  {elemnet, instances }  组件实例  实例名
     *@param { str } 触发动画DOM
     */
    const {
      elemnet,
      instances
    } = instance || e.detail;
    const {
      currentTarget: {
        id
      },
    } = e;
    const str = id ? "#" + id : elemnet;
    // 触发 popover 动画

    const popover = this.selectComponent(str);
    popover && popover.initAnimate();
    //  ————————————————————————————————————————
    //   弹窗显示隐藏
    /**
     * 组件弹窗显示 隐藏
     */
    this.setData({
      [instances]: !this.data[instances],
    });
  },
  //  回顶部
  gotopHandel: function () {
    this.setData({
      scrollTop: 0,
    });
  },
  //  获取 code 码
  getCodeHandel: function (call) {
    wx.login({
      success: (res) => {
        const {
          code
        } = res;
        // console.log(code)
        call(code);
      },
    });
  },
  //  关闭弹窗
  closeHandel: function (e) {
    let {
      detail
    } = e;
    console.log(detail);
    this.setData({
      [detail]: !this.data[detail],
    });
  },
  //  点击预览图片
  previewPicture: function (e) {
    let {
      target: {
        dataset: {
          images,
          index,
          value
        },
      },
    } = e;
    //  拼接路径
    let urlArr = images.map((item, idx) => {
      return (item.src = this.data.seteInfo_https + item.src);
    });

    wx.previewImage({
      urls: urlArr,
      current: urlArr[index],
      success: (res) => { },
    });
  },

  //  test -------------------------------------------------------start
  //  预览图片
  PreviewpHandel(e) {
    let {
      target: {
        dataset: {
          images,
          index
        },
      },
    } = e;

    //  拼接路径
    let urlArr = images.map((item, idx) => {
      return item
    });

    wx.previewImage({
      urls: urlArr,
      current: urlArr[index],
      success: (res) => { },
    });
  },
  // test -------------------------------------------------------end
  //  上传头像
  uploadPictrue: function (arr, call) {
    let promiseAll =
      (arr.length &&
        arr.map((item) => {
          // console.log(item )
          return new Promise((reslove, reject) => {
            wx.uploadFile({
              url: App.globalData.seteInfo_https + "/open/file_api/appletUpload",
              filePath: item.tempFilePath,
              name: "file", //自定义name
              formData: {
                token: wx.getStorageSync("Account").token,
                projectId: App.globalData.project_id,
              },
              success(res) {
                let photo = JSON.parse(res.data);
                // console.log( photo.data )
                arr.push(reslove(photo.data));
              },
              fail(err) {
                wx.showToast({
                  icon: "none",
                  title: "图片上传失败,请稍后在试...",
                });
              },
            });
            return arr;
          });
        })) || [];
    if (promiseAll.length !== 0) {
      Promise.all(promiseAll).then((res) => {
        call(res);
      });
    } else {
      call([]);
    }
  },
  //  瀑布流1
  async generateList(list, load) {
    if (!list && list.length == 0) return;
    if (!load) {
      // 加一个load是因为涉及到搜索的时候，把左右两边的list给清空掉
      this.setData({
        leftList: [],
        rightList: [],
      });
    }
    let {
      leftList,
      rightList
    } = this.data;
    query = wx.createSelectorQuery();
    let status = false;
    for (let item of list) {
      // 通过判断左右高度，来往list中push item
      leftHeight <= rightHeight ? leftList.push(item) : rightList.push(item);
      await this.getViewHeight(leftList, rightList);
    }
  },
  //  瀑布流2
  getViewHeight(leftList, rightList) {
    console.log;
    return new Promise((resolve, reject) => {
      this.setData({
        leftList,
        rightList
      }, function () {
        query.select(".left-flow-item").boundingClientRect();
        query.select(".right-flow-item").boundingClientRect();
        query.exec(function (res) {
          // 获取高度赋值
          leftHeight = res[0]?.height;
          rightHeight = res[1]?.height;
          resolve(true);
        });
      });
    });
  },
  //QQmapSDK（qq地图相关方法）
  QQMapSDk: function (data, callback) {
    console.log(data, callback);
    //实例化地图
    var qqmapsdk = new QQMap({
      //申请的key
      key: "C2GBZ-DP5CU-FTDVC-B2SQC-L4UBZ-ILBO4",
    });

    switch (data.class) {
      //地点搜索，搜索周边poi，比如：“酒店” “餐饮” “娱乐” “学校” 等等
      case "search":
        callback(qqmapsdk);
        // qqmapsdk.search({
        //   keyword:data.keyword,
        //   success(res) {
        //     callback(res)
        //   },
        //   fail: function (res) {
        //     console.log('稍后再试');
        //   },
        //   complete: function (res){
        //     // console.log(res);
        //   }
        // })
        break;
      //用于获取输入关键字的补完与提示，帮助用户快速输入
      case "getSuggestion":
        break;
      //提供由坐标到坐标所在位置的文字描述的转换。输入坐标返回地理位置信息和附近poi列表
      case "reverseGeocoder":
        qqmapsdk.reverseGeocoder({
          location: data.location || "",
          get_poi: 0,
          success(res) {
            callback(res.result);
          },
          fail(res) {
            callback(false);
          },
        });
        break;
      //提供由地址描述到所述位置坐标的转换，与逆地址解析的过程正好相反
      case "geocoder":
        break;
      //提供驾车，步行，骑行，公交的路线规划能力
      case "direction":
        break;
      //获取全国城市列表数据
      case "getCityLis":
        break;
      //通过城市ID返回城市下的区县
      case "getDistrictByCityId":
        break;
      //计算一个点到多点的步行、驾车距离
      case "calculateDistance":
        break;
    }
  },
  //  submit 提交 from 表单
  formSubmitHandel(e) {
    let formObj = e.detail.value;
    // 表单验证
    //   rules_arr 在本地定义 -> 校验规则   rules_arr  => 定义规则 pages  都不一样
    //  this.data.rules_arr
    //  支持 自定义   错误信息  &&  指定 验证返回的信息

    console.log(this.data.rules_arr);
    /**
     * 是自定义 校验 规则
     * 模块化自带校验规则
     */
    /**
     * 验证的对象
     * interface formObj_f = {
     * propName:string:any
     * }
     *  返回的值
     * interface r_verification = {
     *  validationData:(args:Array<T>) => object
     *   mobile_Fnc:(args:string) => object
     *   email_Fnc:(args:string) => object
     * }
     *@param  { type Function  ( formObj:formObj_f ) => r_verification  } verificationEvent
     *@param { type Function } validationDate
     *后续 扩展 ---- 😊
     *
     */
    /**
     * @param {  type Object   } r_obj  验证 错信息
     * @param { type  Boolean }  r_obj.status   验证状态
     * */
    /**
     * 成功的回调 success_fnc
     * 失败的回调 fail_fnc
     */
    let success_fnc = (res) => {
      this.formReturn(formObj);
    };
    let fail_fnc = (err) => {
      let show_message = err.s_data[0];
      wx.showToast({
        icon: "none",
        title: show_message.message,
      });
    };
    verificationEvent(formObj).validationData(
      this.data.rules_arr,
      success_fnc,
      fail_fnc
    );
  },
  //获取收货地址 wx 获取收货地址
  getAddressHandel(e) {
    wx.chooseAddress({
      success(e) {
        console.log(e);
      },
      fail(err) {
        console.log(err);
      },
    });
  },

  //是否登录 
  isLoginHandel() {
    wx.navigateTo({
      url: "/pages/ind-center/index/index",
    });
  },
  //  tabs 选择
  tapsHandel(e) {
    /**
     * 下标  获取 点击 元素
     */
    this.setData({
      tabs_line: e.currentTarget.dataset.index,
    });
  },
  // 提示功能开发中
  ssHandel() {
    wx.showToast({
      title: "此功能开发中",
      icon: "none",
    });
  },
  //  返回上一个路由栈
  rpagesHandel() {
    wx.navigateBack({
      delta: 1,
    });
  },
  // 添加购物车  or 立即购买
  addCartOrBuyHandel(e) {
    let Account = wx.getStorageSync('Account');
    if(!Account.phone){
      wx.navigateTo({
        url: '/pages/auth/login/index'
      })
      return;
    }
    let status = e.currentTarget.dataset.stauts || "";
    let data = e.currentTarget.dataset.item;
    switch (status) {
      case "addcart":
        this.addCartsHandel(data);
        break;
      case "buy":
        this.buyHandel(data);
        break;
    }
  },
  // 立即购买
  buyHandel(data) {
    this.setData({
      show: !this.data.show,
    });
    wx.setStorageSync('toOrderObj', data);
    wx.navigateTo({
      url: '/pages/pay/index/index?type=1'
    });
  },
  //添加购物车
  addCartsHandel(data) {
    App.$https.requestApi('/open/wx_app_api/userShopCarAdd', data).then((r) => {
      if (r.code == 200) {
        let shop_car_num = this.data.data.shop_car_num;
        this.setData({
          show: !this.data.show,
          "data.shop_car_num": shop_car_num + data.num
        })
      }

      wx.showToast({
        icon: 'none',
        title: r.msg
      })
    })
  },
  //规格数量减少
  subEvent(e) {
    let data = e.currentTarget.dataset.item;
    let name = e.currentTarget.dataset.name;
    if (data.num == 1) return;
    if (name == 'now_spec') {
      data.num -= 1;
      this.setData({
        now_spec: data
      })
    }
  },
  //规格数量增加
  addEvent(e) {
    let data = e.currentTarget.dataset.item;
    let name = e.currentTarget.dataset.name;
    if (name == 'now_spec') {
      data.num += 1;
      if (parseInt(data.num) > parseInt(data.stock)) {
        return;
      }
      this.setData({
        now_spec: data
      })
    }
  },
  //  轮播图 滑动事件
  swiperHandel(e) {
    /**
     * @param  { type  Number } current 当前 swiper 子项 所在下标
     * @param { type  String } source 触发方式 touch  手指滑动
     */
    //  触发   current _ index 变化
    let current_index = e.detail.current || 0;
    this.setData({
      is_index: current_index,
    });
  },
  //  test 测试
  //  点击开启购物车弹窗
  selectCartHandel() {
    this.setData({
      show: !this.data.show
    })
  },

  //  test 测试 ——————————————————————————————————————————————————
  //  单个 tabs 选择 
  itabsHandel(e) {

    let d_index = e.currentTarget.dataset.idx,
      c_index = e.currentTarget.dataset.index;

    let str = this.data.current_c.split(',');
    console.log(str[c_index - 1] = d_index);
    str = str.join(",");

    this.setData({
      current_c: str
    })
  },
  //   test -----------------------------测试 读取本地存储
  /**
   * @param {  type  String }  key  key 值
   */
  getStorgeEvevt(key) {
    return wx.getStorageSync(key) || ''
  },
  //  test -----------------------------------测试 修改本地存储
  setStorgeEvent(key, data = {}) {
    if (!key) return;
    wx.setStorageSync(key, data)
  },
  //同意隐私保护
  handleAgreePrivacyAuthorization(r) {
    App.globalData.Privacy = false;
    this.setData({
      "Privacy.showPrivacy": true
    })
  },
  //跳转隐私保护页面
  openPrivacyContract() {
    wx.openPrivacyContract({
      complete(r) {
        console.log(r)
      }
    });
  },
  //关闭隐私
  closePrivacy() {
    this.setData({
      "Privacy.showPrivacy": true
    })
  }
};
//  页面  初始化方法
class Page_methods {
  constructor(slef) {
    this.self = slef;
  }
  /**
   *
   * @param {*} type
   * @param  {...any} args
   */
  async initData(type = "list", ...args) {
    let that = this;
    /**
     * @param type `String`
     * @param path `String`
     * @param project_Id `String`
     * @param page `String`
     * @param limit `String`
     */
    let data = Object.assign({}, {
      type,
    },
      ...args
    );
    /**
     * 是否走请求拦截器   is_request
     * 是否走相应拦截器  is_response
     */
    try {
      let result = await App.$https.getPageList(data);
      let code = result.code; // 获取页面的code  判断是否登录
      let datas = result.data;
      //  遍历存储keys值
      let newData = {};
      for (let key in datas) {
        //  转为小写
        let keys = key.toLocaleLowerCase();
        newData[keys] = datas[key];
        /**
         *  this.self.setData(newData);
         */
        that.self.setData(newData);
      }
      return newData;
    } catch (error) {
      //  处理错误
    }
  }
  //  初始化页面方法
  init_pageMethods() {
    return {
      initData: this.initData,
    };
  }
  /**
   * 倒计时
   */
  countdown(time) {
    /**
     * @param { time } 活动结束时间
     */
    /**
     * 1判断currentTime > time ?  剩余天数 : 0;
     * 2日期格式  yyyy-mm-dd;
     * 3开启定时器
     * 4定时器执行函数
     */
    /**
     * console.log('倒计时...', time);
     */
    /**
     * @type {RegExp} formatRegexp
     */

    let formatRegexp = /\d{4}-((0\d|1[1-2])|([1-9]|1[0-2]))-((0\d|1\d|2\d|3[0-1])|(\d|1\d|2\d|3[0-1]))$/;
    if (formatRegexp) {
      /**
       *@param timeString {  type String  }
       */
      let timeString = time.replaceAll("-", "/");
      /**
       * 天数等于 结束时间戳 减去 当前时间 戳
       * @param  startStamp { type Number } 开始的时间戳
       * @param  endStamp   { type Number } 结束的时间戳
       * @param  delay { type Number} 定时器执行延时时间
       */
      let startStamp,
        endStamp,
        delay = 1000;
      /**
       * @param timerFnc {type Function} 定时器执行函数
       */
      let timerFnc = () => {
        startStamp = new Date();
        endStamp = new Date(timeString);
        let sub = endStamp.valueOf() - startStamp.valueOf();
        //  天数
        let daysRound = Math.floor(sub / (1000 * 60 * 60 * 24));
        //  小时
        let hoursRound = Math.floor((sub / 1000 / 60 / 60) % 24);
        //  分钟
        let minutes = Math.floor((sub / 1000 / 60) % 60);
        // 秒
        let second = Math.floor((sub / 1000) % 60);
        console.debug("%---计时器执行中---%");
        if (daysRound < 0 && hoursRound < 0) {
          daysRound = 0;
          hoursRound = 0;
          minutes = 0;
          second = 0;
        }
        let timerObj = {
          t_day: daysRound,
          t_h: hoursRound,
          t_m: minutes,
          t_s: second,
        };
        if (!(daysRound || hoursRound || minutes || second)) {
          //  清除定时器
          clearInterval(timer);
        } else {
          this.self.setData({
            timerObj,
          });
        }
      };
      /**
       * @param timer 周期定时器
       * @returns timer { type Number}
       * @param delay { type Number} 定时器执行延时时间
       */
      let timer = setInterval(timerFnc, delay);
      return timer;
    }
  }
  /**
   * 清除定时器方法
   * @param timer { type Number } 定时器返回值,是一个数字
   */
  endTimer(timer) {
    if (!timer) return;
    clearInterval(timer);
  }
  // 筛选时间区间
  getDate() {
    //  初始化
    //  所需 数据
    /**
     * @param init { type Function} ;
     * @param date_obj { type Object } 初始化 日期时间;
     * 初始化函数
     */
    let date_obj = {};

    function init() {
      //  年份
      this.currentYear = new Date().getFullYear();
      // 现在几号
      this.currentdate = new Date().getDate();
      // 星期几
      this.weekdate = new Date().getDay(this.currentdate);
      //  月
      this.currentMount = new Date().getMonth() + 1;
      // 获取 当前月有多少天
      this.currentDay = new Date(
        this.currentYear,
        this.currentMount,
        0
      ).getDate();
    }

    /**
     * init.call() 改变this 指向 => date_obj
     */
    init.call(date_obj);
    /**
     * @param getweekDay { type Function }
     * @param month
     * @param day
     * @returns {string}
     */
    let {
      currentDay,
      currentMount,
      currentYear,
      currentdate,
      weekdate,
    } = date_obj;

    function getweekDay(month, day) {
      /**
       *@param week { type String }
       *month 当前月份要减 1;
       */
      let week;
      switch (new Date(2023, month - 1, day).getDay()) {
        case 0:
          week = "(星期天)";
          break;
        case 1:
          week = "(星期一)";
          break;
        case 2:
          week = "(星期二)";
          break;
        case 3:
          week = "(星期三)";
          break;
        case 4:
          week = "(星期四)";
          break;
        case 5:
          week = "(星期五)";
          break;
        case 6:
          week = "(星期六)";
          break;
      }
      return week;
    }

    /**
     * @param getdateArr {type Function}
     * @returns {Array<String>}
     */
    function getdateArr() {
      let arr = [],
        str = "",
        day,
        objArr = [];
      for (let i = currentdate; i <= currentdate + 4; i++) {
        //  判断是否 需要加 0
        str =
          (currentMount > 9 ? `${currentMount}` : `0${currentMount}`) +
          "-" +
          (i > 9 ? `${i}` : `0${i}`);
        /**
         * 如果是这个月的最后一天
         * 处理 --
         // 判断 最后两天星期几
         //  判断是否是最会月的最后一天
         */
        if (currentdate == currentDay) {
          currentMount += 1;
          i = 0;
          currentdate = 0;
        }
        arr.push(str);
      }
      // 处理
      arr = arr.forEach((item, index) => {
        day = item.split("-");
        switch (true) {
          case index == 0:
            objArr.push({
              date: item,
              obweek: "(今天)",
            });
            break;
          case index == 1:
            objArr.push({
              date: item,
              obweek: "(明天)",
            });
            break;
          case index == 2:
            objArr.push({
              date: item,
              obweek: "(后天)",
            });
            break;
          case index == 3:
            objArr.push({
              date: item,
              obweek: getweekDay(currentMount, day[1]),
            });
            break;
          case index == 4:
            objArr.push({
              date: item,
              obweek: getweekDay(currentMount, day[1]),
            });
            break;
        }
      });
      return objArr;
    }

    /**
     * @returns {*}
     */
    function getHouers() {
      let time = new Date();
      let currentHours = time.getHours();
      let currentminutes = time.getMinutes();
      let startTime,
        endTime,
        timeArr = [];
      let timeStamptense = new Date(
        `${currentYear} , ${currentMount + 1
        } ,${currentdate} ,${currentHours}:${currentminutes}`
      );
      //   将当前时间转换为 时间戳
      /**
       * 比较时间戳
       * 比较当前时间 是哪个 区间 筛选数组
       */
      /**
       * 起始时间 9：30 startTime
       * 结束时间21:30 endTime
       * 时间组  timeArr [ ]
       */

      for (let i = 9; i <= 21; i++) {
        timeArr.push(`${i}:30`);
      }
      /**
       *  循环遍历 比较 每个时间戳比较 当前 时间在哪个区间
       */
      return compare(timeArr, timeStamptense);
    }

    /**
     * @param arr
     * @param timeStamp
     * @returns {*}
     */
    function compare(arr, timeStamp) {
      let arr1 = arr
        .map((item, index) => {
          if (arr[index] && arr[index + 1]) {
            let newTime = arr[index].split(":");
            let interval = arr[index + 1].split(":");
            return {
              cstartTime: newTime[0],
              cendTime: newTime[1],
              wstartTime: interval[0],
              wendTime: interval[1],
            };
          }
        })
        .filter(Boolean);
      let arrindex = arr1.findIndex((item, index) => {
        let firstTime = new Date(
          currentYear,
          currentMount,
          currentdate,
          item.cstartTime,
          item.cendTime,
          0
        );
        let lastTime = new Date(
          currentYear,
          currentMount,
          currentdate,
          item.wstartTime,
          item.wendTime
        );
        // console.log( Number(firstTime) ,Number(lastTime)  ,Number(timeStamp) )
        /**
         * 如果当前时间 小于 自提开始时间则显示全部
         *  console.log( Number(firstTime) ,Number(lastTime)  ,Number(timeStamp) )
         * @param 如果  起始时间 小于starttime findIndex 为0   数组就为all
         * @param 如果 起始时间 在某个时间段  findIndex 为  下标 截取splice 过去的时间段
         * @param  {  }`findIndex()` 方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。
         * @example   时间段为 8:30 arr 数组就为 全部
         * @example 时间段为 10:30 arr 为下标截取
         *
         */
        if (timeStamp > firstTime && timeStamp < lastTime) {
          return index;
        } else {
          return false;
        }
      });
      if (~arrindex) {
        arr1.splice(0, arrindex);
      }
      return arr1;
    }

    /**
     * @param { getdateArr } 当前星期几
     * @param { getHouers }  当前 时间 在 哪个区间
     */
    return {
      getdateArr,
      getHouers,
    };
  }
  //   上拉刷新
  upLoad() {
    that = this.self;
    /**
     * 列表  list
     * 详情 detail
     * 判断字段 为 console { list:1,detail:0}
     */
    let restList = () => {
      console.log("列表刷新了");
      /**
       * @param  pages  { :Number } 当前 页数   为 1
       */
      that.setData({
        pages: 1,
      });
      that.init(null, that.data.Page_inset, async () => {
        /**
         * 关闭  刷新
         * 刷新回调  重置当前页面参数
         */
        /**
         * 阻塞3s   请求 error  / or / success
         */
        await new Promise((resolve) => setTimeout(() => resolve(), 3000));
        that.setData({
          triggered: 0,
          is_loding: false,
          pages: 1,
        });
      });
    };
    let restDetaile = () => {
      console.log("详情刷新了");
    };
    if (that.data.console.list) {
      restList();
    } else {
      restDetaile();
    }
  }
  //  下拉加载
  downLoad() {
    that = this.self;
    /**
     * 触底  开启底部加载
     */
    if (that.data.bottom_loding) return;
    console.log("触底了");
    // 开启 底部加载
    that.setData({
      bottom_loding: true,
      pages: (that.data.pages += 1),
    });
    /**
     * 阻塞3s  请求error / or / success
     * 关闭
     */
    that.init(null, that.data.Page_inset, async () => {
      /**
       * 关闭  刷新
       *  回调  重置当前页面参数
       */
      /**
       * 阻塞 3s
       */
      await new Promise((resolve) => setTimeout(() => resolve(), 3000));
      that.setData({
        bottom_loding: false,
      });
    });
  }
  //  签到日期
  siginIn(getYear, getMonth) {

    /**
     * 当前日子是星期几
     * 这个月的第几天
     * 
     * new Date( agrs) 当前时间戳
     *  @parma year 年份
     * @param monthIndex 表示月份的整数，从代表一月的 0 开始到代表十二月的 11 结束。
     * @param day  表示一个月中第几天的整数。默认为 1。 为0  的话就是上个月的最后一天
     * new Date.getDate()根据本地时间，返回一个指定的日期对象为一个月中的哪一日（从 1--31）
     *@param 
     */
    let Dates = new Date()
    //  获取当前年份 
    if (String(getMonth) == 0) {

    } else {
      getYear || (getYear = Dates.getFullYear());
      //  获取当前月份 0 -11
      getMonth || (getMonth = Dates.getMonth());
    }

    function firstGetdates(y, m) {
      //   上个月最后一天星期几  
      let arr = []
      console.log(y, m);
      let index = new Date(y, m, 0).getDate();
      let firstWeekDay = new Date(y, m - 1, index).getDay();
      for (let i = index - firstWeekDay; i <= index; i++) {
        arr.push('')
      }
      return arr
    }

    function currentGetDates(y, m) {
      let arr = []
      let index = new Date(y, m + 1, 0).getDate();
      let currentWeekDay = new Date(y, m, index).getDay();
      // console.log( currentWeekDay )
      for (let i = 1; i <= index; i++) {
        // console.log( i )
        arr.push(i)
      }
      return arr
    }
    //  
    function lastGetDates(y, m) {
      let arr = []
      let index = new Date(y, m + 1, 0).getDate();
      let currentWeekDay = new Date(y, m, index).getDay();
      for (let i = 1; i <= 6 - currentWeekDay; i++) {
        console.log(i)
        arr.push(i)
      }
      return arr
    }
    let newCalemdar = [firstGetdates(getYear, getMonth), currentGetDates(getYear, getMonth), lastGetDates(getYear, getMonth)].flat()
    console.log('当前月', getMonth)
    this.self.setData({
      calendar: newCalemdar,
      currentMonth: (getMonth >= 9 && getMonth <= 11 ? Number(getMonth) + 1 : `0${getMonth + 1}`)
    })
  }
}
//  页面  初始化 数据
class Page_inset extends Page_methods {
  constructor(self) {
    super(self);
  }
  init(call) {
    // this.self.setData({
    //   BOTTOM_DISTANCE: App.globalData.BOTTOM_DISTANCE,
    //   tabbar_items: App.globalData.tabbar_items,
    //   tabbar_config: App.globalData.tabbar_config,
    //   tabbarHeight: App.globalData.tabbarHeight,
    //   statusBarHeight: App.globalData.statusBarHeight,
    //   //  loding 加载 ..
    //   is_loding: true,
    //   //  loding 是否是第一次加载
    //   carry_isloding:true,
    //   //  判断是列表 还是详情
    //   console:{
    //     list:1,
    //     detail:0
    //   },
    //   //  是否刷新
    //   triggered:0,
    //   // 当前页面 页数
    // });
    //  执行的回调 ---

    call && call();
    /**
     * 设置对象  返回 对象
     */
    return {
      project_id: App.globalData.project_id,
      BOTTOM_DISTANCE: App.globalData.BOTTOM_DISTANCE,
      tabbar_items: App.globalData.tabbar_items,
      tabbar_config: App.globalData.tabbar_config,
      tabbarHeight: App.globalData.tabbarHeight,
      navHeight: App.globalData.navHeight,
      btnHeight: App.globalData.btnHeight,
      btnRight: App.globalData.btnRight,
      btnLeft: App.globalData.btnLeft,
      navTop: App.globalData.navTop,
      statusBarHeight: App.globalData.statusBarHeight,
      navbar: {},
      //  loding 加载 ..
      is_loding: true,
      //  loding 是否是第一次加载
      carry_isloding: true,
      //  判断是列表 还是详情
      console: {
        list: 1,
        detail: 0,
      },
      //  是否刷新
      triggered: 0,
      // 当前页面 页数
      pages: 7,
      //  页面加载
      text: "我是初始化数据",
      //  初始化弹窗
      show: false,
      //  底部下拉加载
      bottom_loding: false,
      // test _____________________________________测试数据
      //  tabs 单选 
      current_c: '0,0',
      num: 1,
      // test _____________________________________测试数据
      //  
     
    };
  }
}
exports.Event = event;
exports.Page_inset = Page_inset;